/*  Bluetooth Mesh */

/*
 * Copyright (c) 2017 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <ble_os.h>
#include <string.h>
#include <bt_errno.h>
#include <stdbool.h>
#include <ble_types/types.h>
#include <misc/util.h>
#include <misc/byteorder.h>

#include <bluetooth/bluetooth.h>
#include <bluetooth/conn.h>
#include <api/mesh.h>

#define BT_DBG_ENABLED IS_ENABLED(CONFIG_BT_MESH_DEBUG_MODEL)
#include "common/log.h"

#include "net.h"
#include "foundation.h"

#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
#include "mesh_event_port.h"
#endif

#if defined(CONFIG_BT_MESH_CFG_CLI)

#define CID_NVAL 0xffff

struct comp_data {
    u8_t *status;
    struct net_buf_simple *comp;
};

static bt_s32_t msg_timeout = K_SECONDS(2);

static struct bt_mesh_cfg_cli *cli;

struct bt_mesh_cfg_cli g_cfg_cli = {};

static void comp_data_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
    struct comp_data *param;
    size_t to_copy;
    u8_t status;
    BT_DBG("net_idx 0x%04x app_idx 0x%04x src 0x%04x len %u: %s", ctx->net_idx, ctx->app_idx, ctx->addr, buf->len,
           bt_hex(buf->data, buf->len));

#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_COMP_DATA_STATUS, &evt_data);
    }
#endif

    if (cli->op_pending != OP_DEV_COMP_DATA_STATUS) {
        BT_WARN("Unexpected Composition Data Status");
        return;
    }

    param = cli->op_param;

    status = net_buf_simple_pull_u8(buf);
    if (param) {
        to_copy = MIN(net_buf_simple_tailroom(param->comp), buf->len);
        net_buf_simple_add_mem(param->comp, buf->data, to_copy);
        if (param && param->status) {
            *param->status = status;
        }
        k_sem_give(&cli->op_sync);
    }
}

static void state_status_u8(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf,
                            bt_u32_t expect_status)
{
    u8_t status;

    BT_DBG("net_idx 0x%04x app_idx 0x%04x src 0x%04x len %u: %s", ctx->net_idx, ctx->app_idx, ctx->addr, buf->len,
           bt_hex(buf->data, buf->len));

    if (cli->op_pending != expect_status) {
        BT_WARN("Unexpected Status (0x%08x != 0x%08x)", cli->op_pending, expect_status);
        return;
    }

    status = net_buf_simple_pull_u8(buf);
    if (cli->op_param) {
        *((u8_t *)cli->op_param) = status;
        k_sem_give(&cli->op_sync);
    }
}

static void beacon_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_BEACON_STATUS, &evt_data);
    }
#endif

    state_status_u8(model, ctx, buf, OP_BEACON_STATUS);
}

static void ttl_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_TTL_STATUS, &evt_data);
    }
#endif

    state_status_u8(model, ctx, buf, OP_DEFAULT_TTL_STATUS);
}

static void friend_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_FRIEND_STATUS, &evt_data);
    }
#endif

    state_status_u8(model, ctx, buf, OP_FRIEND_STATUS);
}

static void gatt_proxy_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_PROXY_STATUS, &evt_data);
    }
#endif

    state_status_u8(model, ctx, buf, OP_GATT_PROXY_STATUS);
}

struct relay_param {
    u8_t *status;
    u8_t *transmit;
};

static void relay_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
    struct relay_param *param;
    uint8_t status;
    BT_DBG("net_idx 0x%04x app_idx 0x%04x src 0x%04x len %u: %s", ctx->net_idx, ctx->app_idx, ctx->addr, buf->len,
           bt_hex(buf->data, buf->len));

#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_RELAY_STATUS, &evt_data);
    }
#endif

    if (cli->op_pending != OP_RELAY_STATUS) {
        BT_WARN("Unexpected Relay Status message");
        return;
    }

    param = cli->op_param;
    status = net_buf_simple_pull_u8(buf);

    if (param) {
        *param->transmit = net_buf_simple_pull_u8(buf);
        if (param->status) {
            *param->status = status;
        }

        k_sem_give(&cli->op_sync);
    }
}

struct net_key_param {
    u8_t *status;
    u16_t net_idx;
};

static void net_key_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
    struct net_key_param *param;
    u16_t net_idx;
    u8_t status;

    BT_DBG("net_idx 0x%04x app_idx 0x%04x src 0x%04x len %u: %s", ctx->net_idx, ctx->app_idx, ctx->addr, buf->len,
           bt_hex(buf->data, buf->len));

#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_NETKEY_STATUS, &evt_data);
    }
#endif

    if (cli->op_pending != OP_NET_KEY_STATUS) {
        BT_WARN("Unexpected Net Key Status message");
        return;
    }

    status = net_buf_simple_pull_u8(buf);
    net_idx = net_buf_simple_pull_le16(buf);
    param = cli->op_param;

    if (param && param->net_idx != net_idx) {
        BT_WARN("Net Key Status key index does not match");
        return;
    }

    if (param && param->status) {
        *param->status = status;
    }

    if (param) {
        k_sem_give(&cli->op_sync);
    }
}

struct krp_param {
    uint8_t *status;
    uint16_t net_idx;
    uint8_t *phase;
};

static void net_krp_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
    struct krp_param *param;
    u16_t net_idx;
    u8_t status, phase;

    BT_DBG("net_idx 0x%04x app_idx 0x%04x src 0x%04x len %u: %s\n", ctx->net_idx, ctx->app_idx, ctx->addr, buf->len,
           bt_hex(buf->data, buf->len));

#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_NET_KRP_STATUS, &evt_data);
    }
#endif

    if (cli->op_pending != OP_KRP_STATUS) {
        BT_WARN("Unexpected KRP Status message");
        return;
    }

    status = net_buf_simple_pull_u8(buf);
    net_idx = net_buf_simple_pull_le16(buf);
    phase = net_buf_simple_pull_u8(buf);
    param = cli->op_param;
    if (param) {
        if (param->net_idx != net_idx) {
            BT_WARN("krp Status key index does not match");
            return;
        }

        if (param->status) {
            *param->status = status;
        }

        if (param->phase) {
            *param->phase = phase;
        }

        k_sem_give(&cli->op_sync);
    }
}

struct app_key_param {
    u8_t *status;
    u16_t net_idx;
    u16_t app_idx;
};

static void app_key_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
    struct app_key_param *param;
    u16_t net_idx, app_idx;
    u8_t status;

    BT_DBG("net_idx 0x%04x app_idx 0x%04x src 0x%04x len %u: %s", ctx->net_idx, ctx->app_idx, ctx->addr, buf->len,
           bt_hex(buf->data, buf->len));

#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_APPKEY_STATUS, &evt_data);
    }
#endif

    if (cli->op_pending != OP_APP_KEY_STATUS) {
        BT_WARN("Unexpected App Key Status message");
        return;
    }

    status = net_buf_simple_pull_u8(buf);
    key_idx_unpack(buf, &net_idx, &app_idx);

    param = cli->op_param;
    if (param && (param->net_idx != net_idx || param->app_idx != app_idx)) {
        BT_WARN("App Key Status key indices did not match");
        return;
    }

    if (param && param->status) {
        *param->status = status;
    }

    if (param) {
        k_sem_give(&cli->op_sync);
    }
}

struct mod_app_param {
    u8_t *status;
    u16_t elem_addr;
    u16_t mod_app_idx;
    u16_t mod_id;
    u16_t cid;
};

static void mod_app_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
    u16_t elem_addr, mod_app_idx, mod_id, cid;
    struct mod_app_param *param;
    u8_t status;

    BT_DBG("net_idx 0x%04x app_idx 0x%04x src 0x%04x len %u: %s", ctx->net_idx, ctx->app_idx, ctx->addr, buf->len,
           bt_hex(buf->data, buf->len));

#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_APPKEY_BIND_STATUS, &evt_data);
    }
#endif

    if (cli->op_pending != OP_MOD_APP_STATUS) {
        BT_WARN("Unexpected Model App Status message");
        return;
    }
    status = net_buf_simple_pull_u8(buf);
    elem_addr = net_buf_simple_pull_le16(buf);
    mod_app_idx = net_buf_simple_pull_le16(buf);

    if (buf->len >= 4) {
        cid = net_buf_simple_pull_le16(buf);
    } else {
        cid = CID_NVAL;
    }

    mod_id = net_buf_simple_pull_le16(buf);

    param = cli->op_param;
    if (param) {
        if (param->elem_addr != elem_addr || param->mod_app_idx != mod_app_idx || param->mod_id != mod_id ||
            param->cid != cid) {
            BT_WARN("Model App Status parameters did not match");
            return;
        }

        if (param->status) {
            *param->status = status;
        }

        k_sem_give(&cli->op_sync);
    }
}

struct mod_pub_param {
    u16_t mod_id;
    u16_t cid;
    u16_t elem_addr;
    u8_t *status;
    struct bt_mesh_cfg_mod_pub *pub;
};

static void mod_pub_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
    u16_t mod_id, cid, elem_addr;
    struct mod_pub_param *param;
    u8_t status;

    BT_DBG("net_idx 0x%04x app_idx 0x%04x src 0x%04x len %u: %s", ctx->net_idx, ctx->app_idx, ctx->addr, buf->len,
           bt_hex(buf->data, buf->len));

#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_PUB_STATUS, &evt_data);
    }
#endif

    if (cli->op_pending != OP_MOD_PUB_STATUS) {
        BT_WARN("Unexpected Model Pub Status message");
        return;
    }

    param = cli->op_param;

    if (param) {
        if (param->cid != CID_NVAL) {
            if (buf->len < 14) {
                BT_WARN("Unexpected Mod Pub Status with SIG Model");
                return;
            }

            cid = sys_get_le16(&buf->data[10]);
            mod_id = sys_get_le16(&buf->data[12]);
        } else {
            if (buf->len > 12) {
                BT_WARN("Unexpected Mod Pub Status with Vendor Model");
                return;
            }

            cid = CID_NVAL;
            mod_id = sys_get_le16(&buf->data[10]);
        }

        if (mod_id != param->mod_id || cid != param->cid) {
            BT_WARN("Mod Pub Model ID or Company ID mismatch");
            return;
        }

        status = net_buf_simple_pull_u8(buf);

        elem_addr = net_buf_simple_pull_le16(buf);

        if (elem_addr != param->elem_addr) {
            BT_WARN("Model Pub Status for unexpected element (0x%04x)", elem_addr);
            return;
        }

        if (param->status) {
            *param->status = status;
        }

        if (param->pub) {
            param->pub->addr = net_buf_simple_pull_le16(buf);
            param->pub->app_idx = net_buf_simple_pull_le16(buf);
            param->pub->cred_flag = (param->pub->app_idx & BIT(12));
            param->pub->app_idx &= BIT_MASK(12);
            param->pub->ttl = net_buf_simple_pull_u8(buf);
            param->pub->period = net_buf_simple_pull_u8(buf);
            param->pub->transmit = net_buf_simple_pull_u8(buf);
        }

        k_sem_give(&cli->op_sync);
    }
}

struct mod_sub_param {
    u8_t *status;
    u16_t elem_addr;
    u16_t *sub_addr;
    u16_t *expect_sub;
    u16_t mod_id;
    u16_t cid;
};

static void mod_sub_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
    u16_t elem_addr, sub_addr, mod_id, cid;
    struct mod_sub_param *param;
    u8_t status;

    BT_DBG("net_idx 0x%04x app_idx 0x%04x src 0x%04x len %u: %s", ctx->net_idx, ctx->app_idx, ctx->addr, buf->len,
           bt_hex(buf->data, buf->len));

#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_SUB_STATUS, &evt_data);
    }
#endif

    if (cli->op_pending != OP_MOD_SUB_STATUS) {
        BT_WARN("Unexpected Model Subscription Status message");
        return;
    }

    status = net_buf_simple_pull_u8(buf);
    elem_addr = net_buf_simple_pull_le16(buf);
    sub_addr = net_buf_simple_pull_le16(buf);

    if (buf->len >= 4) {
        cid = net_buf_simple_pull_le16(buf);
    } else {
        cid = CID_NVAL;
    }

    mod_id = net_buf_simple_pull_le16(buf);

    param = cli->op_param;
    if (param) {
        if (param->elem_addr != elem_addr || param->mod_id != mod_id ||
            (param->expect_sub && *param->expect_sub != sub_addr) || param->cid != cid) {
            BT_WARN("Model Subscription Status parameters did not match");
            return;
        }

        if (param->sub_addr) {
            *param->sub_addr = sub_addr;
        }

        if (param->status) {
            *param->status = status;
        }

        k_sem_give(&cli->op_sync);
    }
}

static void mod_sub_list_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
    u16_t elem_addr;
    struct mod_sub_param *param;
    u8_t status;
    u16_t mod_id;

    BT_DBG("net_idx 0x%04x app_idx 0x%04x src 0x%04x len %u: %s", ctx->net_idx, ctx->app_idx, ctx->addr, buf->len,
           bt_hex(buf->data, buf->len));

#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_SUB_LIST, &evt_data);
    }
#endif

    if (cli->op_pending != OP_MOD_SUB_LIST) {
        BT_WARN("Unexpected Model App Status message");
        return;
    }

    status = net_buf_simple_pull_u8(buf);
    elem_addr = net_buf_simple_pull_le16(buf);
    mod_id = net_buf_simple_pull_le16(buf);

    param = (struct mod_sub_param *)cli->op_param;
    if (param) {
        if (param->elem_addr != elem_addr) {
            BT_WARN("Model App Status parameters did not match");
            return;
        }
        if (param->status) {
            *param->status = status;
        }
        if (param->sub_addr) {
            uint8_t index = 0;
            while (buf->len >= 2) {
                param->sub_addr[index++] = net_buf_simple_pull_le16(buf);
            }
        }

        k_sem_give(&cli->op_sync);
    }
    (void)mod_id;
}

static void mod_sub_list_vnd_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx,
                                    struct net_buf_simple *buf)
{
    u16_t elem_addr;
    u16_t company_id;
    struct mod_sub_param *param;
    u8_t status;
    u16_t mod_id;

    BT_DBG("net_idx 0x%04x app_idx 0x%04x src 0x%04x len %u: %s", ctx->net_idx, ctx->app_idx, ctx->addr, buf->len,
           bt_hex(buf->data, buf->len));

#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_SUB_LIST_VND, &evt_data);
    }
#endif

    if (cli->op_pending != OP_MOD_SUB_LIST_VND) {
        BT_WARN("Unexpected Model App Status message");
        return;
    }

    status = net_buf_simple_pull_u8(buf);
    elem_addr = net_buf_simple_pull_le16(buf);
    company_id = net_buf_simple_pull_le16(buf);
    mod_id = net_buf_simple_pull_le16(buf);

    param = (struct mod_sub_param *)cli->op_param;
    if (param) {
        if (param->elem_addr != elem_addr) {
            BT_WARN("Model App Status parameters did not match");
            return;
        }
        if (param->status) {
            *param->status = status;
        }
        if (param->sub_addr) {
            uint8_t index = 0;
            while (buf->len >= 2) {
                param->sub_addr[index++] = net_buf_simple_pull_le16(buf);
            }
        }

        k_sem_give(&cli->op_sync);
    }
    (void)mod_id;
    (void)company_id;
}

struct hb_sub_param {
    u8_t *status;
    struct bt_mesh_cfg_hb_sub *sub;
};

static void hb_sub_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
    struct hb_sub_param *param;
    uint8_t status;
    BT_DBG("net_idx 0x%04x app_idx 0x%04x src 0x%04x len %u: %s", ctx->net_idx, ctx->app_idx, ctx->addr, buf->len,
           bt_hex(buf->data, buf->len));

#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_HB_SUB_STATUS, &evt_data);
    }
#endif

    if (cli->op_pending != OP_HEARTBEAT_SUB_STATUS) {
        BT_WARN("Unexpected Heartbeat Subscription Status message");
        return;
    }

    param = cli->op_param;

    status = net_buf_simple_pull_u8(buf);

    if (param) {
        param->sub->src = net_buf_simple_pull_le16(buf);
        param->sub->dst = net_buf_simple_pull_le16(buf);
        param->sub->period = net_buf_simple_pull_u8(buf);
        param->sub->count = net_buf_simple_pull_u8(buf);
        param->sub->min = net_buf_simple_pull_u8(buf);
        param->sub->max = net_buf_simple_pull_u8(buf);
        if (param->status) {
            *param->status = status;
        }

        k_sem_give(&cli->op_sync);
    }
}

struct hb_pub_param {
    u8_t *status;
    struct bt_mesh_cfg_hb_pub *pub;
};

static void hb_pub_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
    struct hb_pub_param *param;
    uint8_t status;
    BT_DBG("net_idx 0x%04x app_idx 0x%04x src 0x%04x len %u: %s", ctx->net_idx, ctx->app_idx, ctx->addr, buf->len,
           bt_hex(buf->data, buf->len));

#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_HB_PUB_STATUS, &evt_data);
    }
#endif

    if (cli->op_pending != OP_HEARTBEAT_PUB_STATUS) {
        BT_WARN("Unexpected Heartbeat Publication Status message");
        return;
    }

    param = cli->op_param;

    status = net_buf_simple_pull_u8(buf);

    if (param && param->pub) {
        param->pub->dst = net_buf_simple_pull_le16(buf);
        param->pub->count = net_buf_simple_pull_u8(buf);
        param->pub->period = net_buf_simple_pull_u8(buf);
        param->pub->ttl = net_buf_simple_pull_u8(buf);
        param->pub->feat = net_buf_simple_pull_u8(buf);
        param->pub->net_idx = net_buf_simple_pull_u8(buf);
    }
    if (param && param->status) {
        *param->status = status;
    }
    if (param) {
        k_sem_give(&cli->op_sync);
    }
}

static void node_reset_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
    BT_DBG("net_idx 0x%04x app_idx 0x%04x src 0x%04x len %u: %s", ctx->net_idx, ctx->app_idx, ctx->addr, buf->len,
           bt_hex(buf->data, buf->len));

#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_NODE_RESET_STATUS, &evt_data);
    }
#endif
    if (cli->op_pending != OP_NODE_RESET_STATUS) {
        BT_WARN("Unexpected Node Reset Status message");
        return;
    }

    k_sem_give(&cli->op_sync);
}

/*[Genie begin] add by wenbing.cwb at 2021-01-21*/
#ifdef CONFIG_BT_MESH_CTRL_RELAY
struct cli_cr_param {
    u8_t *status;
    struct ctrl_relay_param *cr_p;
};

static void cli_ctrl_relay_status(struct bt_mesh_model *model, struct bt_mesh_msg_ctx *ctx, struct net_buf_simple *buf)
{
    struct cli_cr_param *param;

    BT_DBG("net_idx 0x%04x app_idx 0x%04x src 0x%04x len %u: %s", ctx->net_idx, ctx->app_idx, ctx->addr, buf->len,
           bt_hex(buf->data, buf->len));

#ifdef CONFIG_BT_MESH_EVENT_CALLBACK
    bt_mesh_model_evt_t evt_data;
    evt_data.source_addr = ctx->addr;
    evt_data.user_data = buf;
    mesh_model_evt_cb event_cb = bt_mesh_event_get_cb_func();
    if (event_cb) {
        event_cb(BT_MESH_MODEL_EVT_CTRL_RELAY_STATUS, &evt_data);
    }
#endif

    if (cli->op_pending != OP_CTRL_RELAY_CONF_STATUS) {
        BT_WARN("Unexpected Ctrl Relay Status message");
        return;
    }

    param = cli->op_param;

    *param->status = net_buf_simple_pull_u8(buf);

    if (param->cr_p) {
        param->cr_p->enable = net_buf_simple_pull_u8(buf);
        param->cr_p->trd_n = net_buf_simple_pull_u8(buf);
        param->cr_p->rssi = net_buf_simple_pull_u8(buf);
        param->cr_p->sta_period = net_buf_simple_pull_u8(buf);
        param->cr_p->chk_period = net_buf_simple_pull_u8(buf);
        param->cr_p->req_period = net_buf_simple_pull_u8(buf);
    }

    k_sem_give(&cli->op_sync);
}
#endif
/*[Genie end] add by wenbing.cwb at 2021-01-21*/

const struct bt_mesh_model_op bt_mesh_cfg_cli_op[] = {
    { OP_DEV_COMP_DATA_STATUS, 15, comp_data_status },
    { OP_BEACON_STATUS, 1, beacon_status },
    { OP_DEFAULT_TTL_STATUS, 1, ttl_status },
    { OP_FRIEND_STATUS, 1, friend_status },
    { OP_GATT_PROXY_STATUS, 1, gatt_proxy_status },
    { OP_RELAY_STATUS, 2, relay_status },
    { OP_NET_KEY_STATUS, 3, net_key_status },
    { OP_APP_KEY_STATUS, 4, app_key_status },
    { OP_MOD_APP_STATUS, 7, mod_app_status },
    { OP_MOD_PUB_STATUS, 12, mod_pub_status },
    { OP_MOD_SUB_STATUS, 7, mod_sub_status },
    { OP_HEARTBEAT_SUB_STATUS, 9, hb_sub_status },
    { OP_HEARTBEAT_PUB_STATUS, 10, hb_pub_status },
    { OP_NODE_RESET_STATUS, 0, node_reset_status },
    { OP_KRP_STATUS, 4, net_krp_status },
    { OP_MOD_SUB_LIST, 5, mod_sub_list_status },
    { OP_MOD_SUB_LIST_VND, 7, mod_sub_list_vnd_status },
/*[Genie begin] add by wenbing.cwb at 2021-01-21*/
#ifdef CONFIG_BT_MESH_CTRL_RELAY
    { OP_CTRL_RELAY_CONF_STATUS, 7, cli_ctrl_relay_status },
#endif
    /*[Genie end] add by wenbing.cwb at 2021-01-21*/
    BT_MESH_MODEL_OP_END,
};

static int cli_prepare(void *param, bt_u32_t op)
{
    if (!cli) {
        BT_ERR("No available Configuration Client context!");
        return -EINVAL;
    }

    if (cli->op_pending) {
        BT_WARN("Another synchronous operation pending");
        return -EBUSY;
    }

    cli->op_param = param;
    cli->op_pending = op;

    return 0;
}

static void cli_reset(void)
{
    cli->op_pending = 0;
    cli->op_param = NULL;
}

static int cli_wait(void)
{
    int err;

    err = k_sem_take(&cli->op_sync, msg_timeout);

    cli_reset();

    return err;
}

int bt_mesh_cfg_comp_data_get(u16_t net_idx, u16_t addr, u8_t page, u8_t *status, struct net_buf_simple *comp)
{
    if (status && comp == NULL) {
        return -EINVAL;
    }

    NET_BUF_SIMPLE_DEFINE(msg, 2 + 1 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct comp_data param = {
        .status = status,
        .comp = comp,
    };
    int err;

    err = cli_prepare(&param, OP_DEV_COMP_DATA_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_DEV_COMP_DATA_GET);
    net_buf_simple_add_u8(&msg, page);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }
    if (!status) {
        cli_reset();
        return 0;
    }
    return cli_wait();
}

static int get_state_u8(u16_t net_idx, u16_t addr, bt_u32_t op, bt_u32_t rsp, u8_t *val)
{
    NET_BUF_SIMPLE_DEFINE(msg, 2 + 0 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    int err;

    err = cli_prepare(val, rsp);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, op);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }
    if (!val) {
        cli_reset();
        return 0;
    }
    return cli_wait();
}

static int set_state_u8(u16_t net_idx, u16_t addr, bt_u32_t op, bt_u32_t rsp, u8_t new_val, u8_t *val)
{
    NET_BUF_SIMPLE_DEFINE(msg, 2 + 1 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    int err;

    err = cli_prepare(val, rsp);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, op);
    net_buf_simple_add_u8(&msg, new_val);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }
    if (!val) {
        cli_reset();
        return 0;
    }
    return cli_wait();
}

int bt_mesh_cfg_beacon_get(u16_t net_idx, u16_t addr, u8_t *status)
{
    return get_state_u8(net_idx, addr, OP_BEACON_GET, OP_BEACON_STATUS, status);
}

int bt_mesh_cfg_beacon_set(u16_t net_idx, u16_t addr, u8_t val, u8_t *status)
{
    if (val > BT_MESH_BEACON_ENABLED) {
        return -EINVAL;
    }
    return set_state_u8(net_idx, addr, OP_BEACON_SET, OP_BEACON_STATUS, val, status);
}

int bt_mesh_cfg_ttl_get(u16_t net_idx, u16_t addr, u8_t *ttl)
{
    if (ttl == NULL) {
        return -EINVAL;
    }
    return get_state_u8(net_idx, addr, OP_DEFAULT_TTL_GET, OP_DEFAULT_TTL_STATUS, ttl);
}

int bt_mesh_cfg_ttl_set(u16_t net_idx, u16_t addr, u8_t val, u8_t *ttl)
{
    if (ttl == NULL || val == 0x01 || val > BT_MESH_TTL_MAX) {
        return -EINVAL;
    }
    return set_state_u8(net_idx, addr, OP_DEFAULT_TTL_SET, OP_DEFAULT_TTL_STATUS, val, ttl);
}

int bt_mesh_cfg_friend_get(u16_t net_idx, u16_t addr, u8_t *status)
{
    return get_state_u8(net_idx, addr, OP_FRIEND_GET, OP_FRIEND_STATUS, status);
}

int bt_mesh_cfg_friend_set(u16_t net_idx, u16_t addr, u8_t val, u8_t *status)
{
    if (val > BT_MESH_FRIEND_ENABLED) {
        return -EINVAL;
    }
    return set_state_u8(net_idx, addr, OP_FRIEND_SET, OP_FRIEND_STATUS, val, status);
}

int bt_mesh_cfg_gatt_proxy_get(u16_t net_idx, u16_t addr, u8_t *status)
{
    return get_state_u8(net_idx, addr, OP_GATT_PROXY_GET, OP_GATT_PROXY_STATUS, status);
}

int bt_mesh_cfg_gatt_proxy_set(u16_t net_idx, u16_t addr, u8_t val, u8_t *status)
{
    if (val > BT_MESH_GATT_PROXY_ENABLED) {
        return -EINVAL;
    }
    return set_state_u8(net_idx, addr, OP_GATT_PROXY_SET, OP_GATT_PROXY_STATUS, val, status);
}

int bt_mesh_cfg_relay_get(u16_t net_idx, u16_t addr, u8_t *status, u8_t *transmit)
{
    if (transmit == NULL) {
        return -EINVAL;
    }

    NET_BUF_SIMPLE_DEFINE(msg, 2 + 0 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct relay_param param = {
        .status = status,
        .transmit = transmit,
    };
    int err;

    err = cli_prepare(&param, OP_RELAY_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_RELAY_GET);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }
    if (!status) {
        cli_reset();
        return 0;
    }
    return cli_wait();
}

int bt_mesh_cfg_relay_set(u16_t net_idx, u16_t addr, u8_t new_relay, u8_t new_transmit, u8_t *status, u8_t *transmit)
{
    if (transmit == NULL) {
        return -EINVAL;
    }

    if (new_relay > BT_MESH_RELAY_ENABLED) {
        return -EINVAL;
    }

    NET_BUF_SIMPLE_DEFINE(msg, 2 + 2 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct relay_param param = {
        .status = status,
        .transmit = transmit,
    };
    int err;

    err = cli_prepare(&param, OP_RELAY_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_RELAY_SET);
    net_buf_simple_add_u8(&msg, new_relay);
    net_buf_simple_add_u8(&msg, new_transmit);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }
    if (!status) {
        cli_reset();
        return 0;
    }
    return cli_wait();
}

int bt_mesh_cfg_net_key_add(u16_t net_idx, u16_t addr, u16_t key_net_idx, const u8_t net_key[16], u8_t *status)
{
    NET_BUF_SIMPLE_DEFINE(msg, 2 + 18 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct net_key_param param = {
        .status = status,
        .net_idx = key_net_idx,
    };
    int err;

    err = cli_prepare(&param, OP_NET_KEY_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_NET_KEY_ADD);
    net_buf_simple_add_le16(&msg, key_net_idx);
    net_buf_simple_add_mem(&msg, net_key, 16);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }
    if (!status) {
        cli_reset();
        return 0;
    }

    return cli_wait();
}

int bt_mesh_cfg_net_key_update(u16_t net_idx, u16_t addr, u16_t key_net_idx, const u8_t net_key[16], u8_t *status)
{
    NET_BUF_SIMPLE_DEFINE(msg, 2 + 18 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct net_key_param param = {
        .status = status,
        .net_idx = key_net_idx,
    };
    int err;

    err = cli_prepare(&param, OP_NET_KEY_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_NET_KEY_UPDATE);
    net_buf_simple_add_le16(&msg, key_net_idx);
    net_buf_simple_add_mem(&msg, net_key, 16);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }

    if (!status) {
        cli_reset();
        return 0;
    }

    return cli_wait();
}

int bt_mesh_cfg_krp_set(u16_t net_idx, u16_t addr, u16_t key_net_idx, u8_t *phase, u8_t *status)
{
    NET_BUF_SIMPLE_DEFINE(msg, 2 + 3 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct krp_param param = {
        .status = status,
        .net_idx = key_net_idx,
        .phase = phase,
    };
    int err;

    err = cli_prepare(&param, OP_KRP_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_KRP_SET);
    net_buf_simple_add_le16(&msg, key_net_idx);
    net_buf_simple_add_u8(&msg, *phase);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }

    if (!status) {
        cli_reset();
        return 0;
    }

    return cli_wait();
}

int bt_mesh_cfg_krp_get(u16_t net_idx, u16_t addr, u16_t key_net_idx, u8_t *phase, u8_t *status)
{
    NET_BUF_SIMPLE_DEFINE(msg, 2 + 2 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct krp_param param = {
        .status = status,
        .net_idx = key_net_idx,
        .phase = phase,
    };
    int err;
    err = cli_prepare(&param, OP_KRP_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_KRP_GET);
    net_buf_simple_add_le16(&msg, key_net_idx);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }

    if (!status) {
        cli_reset();
        return 0;
    }

    return cli_wait();
}

int bt_mesh_cfg_app_key_add(u16_t net_idx, u16_t addr, u16_t key_net_idx, u16_t key_app_idx, const u8_t app_key[16],
                            u8_t *status)
{
    NET_BUF_SIMPLE_DEFINE(msg, 1 + 19 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };

    struct app_key_param param = {
        .status = status,
        .net_idx = key_net_idx,
        .app_idx = key_app_idx,
    };

    int err;

    err = cli_prepare(&param, OP_APP_KEY_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_APP_KEY_ADD);
    key_idx_pack(&msg, key_net_idx, key_app_idx);
    net_buf_simple_add_mem(&msg, app_key, 16);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }
    if (!status) {
        cli_reset();
        return 0;
    }
    return cli_wait();
}

int bt_mesh_cfg_app_key_update(u16_t net_idx, u16_t addr, u16_t key_net_idx, u16_t key_app_idx, const u8_t app_key[16],
                               u8_t *status)
{
    NET_BUF_SIMPLE_DEFINE(msg, 1 + 19 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct app_key_param param = {
        .status = status,
        .net_idx = key_net_idx,
        .app_idx = key_app_idx,
    };
    int err;

    err = cli_prepare(&param, OP_APP_KEY_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_APP_KEY_UPDATE);
    key_idx_pack(&msg, key_net_idx, key_app_idx);
    net_buf_simple_add_mem(&msg, app_key, 16);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }

    if (!status) {
        cli_reset();
        return 0;
    }

    return cli_wait();
}

static int mod_app_bind(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t mod_app_idx, u16_t mod_id, u16_t cid,
                        u8_t *status)
{
    NET_BUF_SIMPLE_DEFINE(msg, 2 + 8 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };

    struct mod_app_param param = {
        .status = status,
        .elem_addr = elem_addr,
        .mod_app_idx = mod_app_idx,
        .mod_id = mod_id,
        .cid = cid,
    };

    int err;

    err = cli_prepare(&param, OP_MOD_APP_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_MOD_APP_BIND);
    net_buf_simple_add_le16(&msg, elem_addr);
    net_buf_simple_add_le16(&msg, mod_app_idx);

    if (cid != CID_NVAL) {
        net_buf_simple_add_le16(&msg, cid);
    }

    net_buf_simple_add_le16(&msg, mod_id);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }

    if (!status) {
        cli_reset();
        return 0;
    }

    return cli_wait();
}

static int mod_app_unbind(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t mod_app_idx, u16_t mod_id, u16_t cid,
                          u8_t *status)
{
    NET_BUF_SIMPLE_DEFINE(msg, 2 + 8 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };

    struct mod_app_param param = {
        .status = status,
        .elem_addr = elem_addr,
        .mod_app_idx = mod_app_idx,
        .mod_id = mod_id,
        .cid = cid,
    };

    int err;

    err = cli_prepare(&param, OP_MOD_APP_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_MOD_APP_UNBIND);
    net_buf_simple_add_le16(&msg, elem_addr);
    net_buf_simple_add_le16(&msg, mod_app_idx);

    if (cid != CID_NVAL) {
        net_buf_simple_add_le16(&msg, cid);
    }

    net_buf_simple_add_le16(&msg, mod_id);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }

    if (!status) {
        cli_reset();
        return 0;
    }

    return cli_wait();
}

int bt_mesh_cfg_mod_app_unbind(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t mod_app_idx, u16_t mod_id,
                               u8_t *status)
{
    return mod_app_unbind(net_idx, addr, elem_addr, mod_app_idx, mod_id, CID_NVAL, status);
}

int bt_mesh_cfg_mod_app_unbind_vnd(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t mod_app_idx, u16_t mod_id,
                                   u16_t cid, u8_t *status)
{
    if (cid == CID_NVAL) {
        return -EINVAL;
    }

    return mod_app_unbind(net_idx, addr, elem_addr, mod_app_idx, mod_id, cid, status);
}

int bt_mesh_cfg_mod_app_bind(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t mod_app_idx, u16_t mod_id, u8_t *status)
{
    return mod_app_bind(net_idx, addr, elem_addr, mod_app_idx, mod_id, CID_NVAL, status);
}

int bt_mesh_cfg_mod_app_bind_vnd(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t mod_app_idx, u16_t mod_id, u16_t cid,
                                 u8_t *status)
{
    if (cid == CID_NVAL) {
        return -EINVAL;
    }

    return mod_app_bind(net_idx, addr, elem_addr, mod_app_idx, mod_id, cid, status);
}

static int mod_sub(bt_u32_t op, u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t sub_addr, u16_t mod_id, u16_t cid,
                   u8_t *status)
{
    NET_BUF_SIMPLE_DEFINE(msg, 2 + 8 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct mod_sub_param param = {
        .status = status,
        .elem_addr = elem_addr,
        .expect_sub = &sub_addr,
        .mod_id = mod_id,
        .cid = cid,
    };
    int err;

    err = cli_prepare(&param, OP_MOD_SUB_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, op);
    net_buf_simple_add_le16(&msg, elem_addr);
    net_buf_simple_add_le16(&msg, sub_addr);

    if (cid != CID_NVAL) {
        net_buf_simple_add_le16(&msg, cid);
    }

    net_buf_simple_add_le16(&msg, mod_id);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }

    if (!status) {
        cli_reset();
        return 0;
    }

    return cli_wait();
}

int bt_mesh_cfg_mod_sub_add(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t sub_addr, u16_t mod_id, u8_t *status)
{
    return mod_sub(OP_MOD_SUB_ADD, net_idx, addr, elem_addr, sub_addr, mod_id, CID_NVAL, status);
}

int bt_mesh_cfg_mod_sub_add_vnd(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t sub_addr, u16_t mod_id, u16_t cid,
                                u8_t *status)
{
    if (cid == CID_NVAL) {
        return -EINVAL;
    }

    return mod_sub(OP_MOD_SUB_ADD, net_idx, addr, elem_addr, sub_addr, mod_id, cid, status);
}

int bt_mesh_cfg_mod_sub_del(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t sub_addr, u16_t mod_id, u8_t *status)
{
    return mod_sub(OP_MOD_SUB_DEL, net_idx, addr, elem_addr, sub_addr, mod_id, CID_NVAL, status);
}

int bt_mesh_cfg_mod_sub_del_vnd(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t sub_addr, u16_t mod_id, u16_t cid,
                                u8_t *status)
{
    if (cid == CID_NVAL) {
        return -EINVAL;
    }

    return mod_sub(OP_MOD_SUB_DEL, net_idx, addr, elem_addr, sub_addr, mod_id, cid, status);
}

int bt_mesh_cfg_mod_sub_overwrite(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t sub_addr, u16_t mod_id,
                                  u8_t *status)
{
    return mod_sub(OP_MOD_SUB_OVERWRITE, net_idx, addr, elem_addr, sub_addr, mod_id, CID_NVAL, status);
}

int bt_mesh_cfg_mod_sub_overwrite_vnd(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t sub_addr, u16_t mod_id,
                                      u16_t cid, u8_t *status)
{
    if (cid == CID_NVAL) {
        return -EINVAL;
    }

    return mod_sub(OP_MOD_SUB_OVERWRITE, net_idx, addr, elem_addr, sub_addr, mod_id, cid, status);
}

static int mod_sub_va(bt_u32_t op, u16_t net_idx, u16_t addr, u16_t elem_addr, const u8_t label[16], u16_t mod_id,
                      u16_t cid, u16_t *virt_addr, u8_t *status)
{
    NET_BUF_SIMPLE_DEFINE(msg, 2 + 22 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct mod_sub_param param = {
        .status = status,
        .elem_addr = elem_addr,
        .sub_addr = virt_addr,
        .mod_id = mod_id,
        .cid = cid,
    };
    int err;

    err = cli_prepare(&param, OP_MOD_SUB_STATUS);
    if (err) {
        return err;
    }

    BT_DBG("net_idx 0x%04x addr 0x%04x elem_addr 0x%04x label %s", net_idx, addr, elem_addr, label);
    BT_DBG("mod_id 0x%04x cid 0x%04x", mod_id, cid);

    bt_mesh_model_msg_init(&msg, op);
    net_buf_simple_add_le16(&msg, elem_addr);
    net_buf_simple_add_mem(&msg, label, 16);

    if (cid != CID_NVAL) {
        net_buf_simple_add_le16(&msg, cid);
    }

    net_buf_simple_add_le16(&msg, mod_id);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }

    if (!status) {
        cli_reset();
        return 0;
    }

    return cli_wait();
}

int bt_mesh_cfg_mod_sub_va_add(u16_t net_idx, u16_t addr, u16_t elem_addr, const u8_t label[16], u16_t mod_id,
                               u16_t *virt_addr, u8_t *status)
{
    if (virt_addr == NULL) {
        return -EINVAL;
    }
    return mod_sub_va(OP_MOD_SUB_VA_ADD, net_idx, addr, elem_addr, label, mod_id, CID_NVAL, virt_addr, status);
}

int bt_mesh_cfg_mod_sub_va_add_vnd(u16_t net_idx, u16_t addr, u16_t elem_addr, const u8_t label[16], u16_t mod_id,
                                   u16_t cid, u16_t *virt_addr, u8_t *status)
{
    if (cid == CID_NVAL || virt_addr == NULL) {
        return -EINVAL;
    }

    return mod_sub_va(OP_MOD_SUB_VA_ADD, net_idx, addr, elem_addr, label, mod_id, cid, virt_addr, status);
}

int bt_mesh_cfg_mod_sub_va_del(u16_t net_idx, u16_t addr, u16_t elem_addr, const u8_t label[16], u16_t mod_id,
                               u16_t *virt_addr, u8_t *status)
{
    if (virt_addr == NULL) {
        return -EINVAL;
    }
    return mod_sub_va(OP_MOD_SUB_VA_DEL, net_idx, addr, elem_addr, label, mod_id, CID_NVAL, virt_addr, status);
}

int bt_mesh_cfg_mod_sub_va_del_vnd(u16_t net_idx, u16_t addr, u16_t elem_addr, const u8_t label[16], u16_t mod_id,
                                   u16_t cid, u16_t *virt_addr, u8_t *status)
{
    if (cid == CID_NVAL || virt_addr == NULL) {
        return -EINVAL;
    }

    return mod_sub_va(OP_MOD_SUB_VA_DEL, net_idx, addr, elem_addr, label, mod_id, cid, virt_addr, status);
}

int bt_mesh_cfg_mod_sub_va_overwrite(u16_t net_idx, u16_t addr, u16_t elem_addr, const u8_t label[16], u16_t mod_id,
                                     u16_t *virt_addr, u8_t *status)
{
    if (virt_addr == NULL) {
        return -EINVAL;
    }
    return mod_sub_va(OP_MOD_SUB_VA_OVERWRITE, net_idx, addr, elem_addr, label, mod_id, CID_NVAL, virt_addr, status);
}

int bt_mesh_cfg_mod_sub_va_overwrite_vnd(u16_t net_idx, u16_t addr, u16_t elem_addr, const u8_t label[16], u16_t mod_id,
                                         u16_t cid, u16_t *virt_addr, u8_t *status)
{
    if (cid == CID_NVAL || virt_addr == NULL) {
        return -EINVAL;
    }

    return mod_sub_va(OP_MOD_SUB_VA_OVERWRITE, net_idx, addr, elem_addr, label, mod_id, cid, virt_addr, status);
}

static int mod_pub_get(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t mod_id, u16_t cid,
                       struct bt_mesh_cfg_mod_pub *pub, u8_t *status)
{
    NET_BUF_SIMPLE_DEFINE(msg, 2 + 6 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct mod_pub_param param = {
        .mod_id = mod_id,
        .cid = cid,
        .elem_addr = elem_addr,
        .status = status,
        .pub = pub,
    };
    int err;

    err = cli_prepare(&param, OP_MOD_PUB_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_MOD_PUB_GET);

    net_buf_simple_add_le16(&msg, elem_addr);

    if (cid != CID_NVAL) {
        net_buf_simple_add_le16(&msg, cid);
    }

    net_buf_simple_add_le16(&msg, mod_id);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }

    if (!status) {
        cli_reset();
        return 0;
    }

    return cli_wait();
}

int bt_mesh_cfg_mod_pub_get(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t mod_id, struct bt_mesh_cfg_mod_pub *pub,
                            u8_t *status)
{
    if ((pub == NULL && status) || (pub && status == NULL)) {
        return -EINVAL;
    }
    return mod_pub_get(net_idx, addr, elem_addr, mod_id, CID_NVAL, pub, status);
}

int bt_mesh_cfg_mod_sub_get(u16_t net_idx, u16_t addr, u16_t mod_id, uint16_t *sub, u8_t *status)
{
    if ((sub == NULL && status) || (sub && status == NULL)) {
        return -EINVAL;
    }

    NET_BUF_SIMPLE_DEFINE(msg, 2 + 4 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };

    struct mod_sub_param param = {
        .status = status,
        .elem_addr = addr,
        .sub_addr = sub,
    };
    int err;

    err = cli_prepare(&param, OP_MOD_SUB_LIST);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_MOD_SUB_GET);
    net_buf_simple_add_le16(&msg, addr);
    net_buf_simple_add_le16(&msg, mod_id);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }

    if (!status) {
        cli_reset();
        return 0;
    }

    return cli_wait();
}

int bt_mesh_cfg_mod_sub_get_vnd(u16_t net_idx, u16_t addr, u16_t mod_id, u16_t cid, uint16_t *sub, u8_t *status)
{
    if ((sub == NULL && status) || (sub && status == NULL)) {
        return -EINVAL;
    }

    NET_BUF_SIMPLE_DEFINE(msg, 2 + 6 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };

    struct mod_sub_param param = {
        .status = status,
        .elem_addr = addr,
        .sub_addr = sub,
    };
    int err;

    err = cli_prepare(&param, OP_MOD_SUB_LIST_VND);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_MOD_SUB_GET_VND);
    net_buf_simple_add_le16(&msg, addr);
    net_buf_simple_add_le16(&msg, cid);
    net_buf_simple_add_le16(&msg, mod_id);
    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }

    if (!status) {
        cli_reset();
        return 0;
    }

    return cli_wait();
}

int bt_mesh_cfg_mod_pub_get_vnd(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t mod_id, u16_t cid,
                                struct bt_mesh_cfg_mod_pub *pub, u8_t *status)
{
    if (cid == CID_NVAL || (pub == NULL && status) || (pub && status == NULL)) {
        return -EINVAL;
    }

    return mod_pub_get(net_idx, addr, elem_addr, mod_id, cid, pub, status);
}

static int mod_pub_set(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t mod_id, u16_t cid,
                       struct bt_mesh_cfg_mod_pub *pub, u8_t *status)
{
    NET_BUF_SIMPLE_DEFINE(msg, 2 + 13 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct mod_pub_param param = {
        .mod_id = mod_id,
        .cid = cid,
        .elem_addr = elem_addr,
        .status = status,
        .pub = pub,
    };
    int err;

    err = cli_prepare(&param, OP_MOD_PUB_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_MOD_PUB_SET);

    net_buf_simple_add_le16(&msg, elem_addr);
    net_buf_simple_add_le16(&msg, pub->addr);
    net_buf_simple_add_le16(&msg, (pub->app_idx & (pub->cred_flag << 12)));
    net_buf_simple_add_u8(&msg, pub->ttl);
    net_buf_simple_add_u8(&msg, pub->period);
    net_buf_simple_add_u8(&msg, pub->transmit);

    if (cid != CID_NVAL) {
        net_buf_simple_add_le16(&msg, cid);
    }

    net_buf_simple_add_le16(&msg, mod_id);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }

    if (!status) {
        cli_reset();
        return 0;
    }

    return cli_wait();
}

int bt_mesh_cfg_mod_pub_set(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t mod_id, struct bt_mesh_cfg_mod_pub *pub,
                            u8_t *status)
{
    if (pub == NULL) {
        return -EINVAL;
    }

    return mod_pub_set(net_idx, addr, elem_addr, mod_id, CID_NVAL, pub, status);
}

int bt_mesh_cfg_mod_pub_set_vnd(u16_t net_idx, u16_t addr, u16_t elem_addr, u16_t mod_id, u16_t cid,
                                struct bt_mesh_cfg_mod_pub *pub, u8_t *status)
{
    if (cid == CID_NVAL || pub == NULL) {
        return -EINVAL;
    }

    return mod_pub_set(net_idx, addr, elem_addr, mod_id, cid, pub, status);
}

int bt_mesh_cfg_hb_sub_set(u16_t net_idx, u16_t addr, struct bt_mesh_cfg_hb_sub *sub, u8_t *status)
{
    if (sub == NULL) {
        return -EINVAL;
    }

    NET_BUF_SIMPLE_DEFINE(msg, 2 + 5 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct hb_sub_param param = {
        .status = status,
        .sub = sub,
    };
    int err;

    err = cli_prepare(&param, OP_HEARTBEAT_SUB_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_HEARTBEAT_SUB_SET);
    net_buf_simple_add_le16(&msg, sub->src);
    net_buf_simple_add_le16(&msg, sub->dst);
    net_buf_simple_add_u8(&msg, sub->period);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }
    if (!status) {
        cli_reset();
        return 0;
    }
    return cli_wait();
}

int bt_mesh_cfg_hb_sub_get(u16_t net_idx, u16_t addr, struct bt_mesh_cfg_hb_sub *sub, u8_t *status)
{
    if (sub == NULL) {
        return -EINVAL;
    }

    NET_BUF_SIMPLE_DEFINE(msg, 2 + 0 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct hb_sub_param param = {
        .status = status,
        .sub = sub,
    };
    int err;

    err = cli_prepare(&param, OP_HEARTBEAT_SUB_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_HEARTBEAT_SUB_GET);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }
    if (!status) {
        cli_reset();
        return 0;
    }
    return cli_wait();
}

int bt_mesh_cfg_hb_pub_set(u16_t net_idx, u16_t addr, const struct bt_mesh_cfg_hb_pub *pub, u8_t *status)
{
    if (pub == NULL) {
        return -EINVAL;
    }

    NET_BUF_SIMPLE_DEFINE(msg, 2 + 9 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct hb_pub_param param = {
        .status = status,
    };
    int err;

    err = cli_prepare(&param, OP_HEARTBEAT_PUB_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_HEARTBEAT_PUB_SET);
    net_buf_simple_add_le16(&msg, pub->dst);
    net_buf_simple_add_u8(&msg, pub->count);
    net_buf_simple_add_u8(&msg, pub->period);
    net_buf_simple_add_u8(&msg, pub->ttl);
    net_buf_simple_add_le16(&msg, pub->feat);
    net_buf_simple_add_le16(&msg, pub->net_idx);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }
    if (!status) {
        cli_reset();
        return 0;
    }
    return cli_wait();
}

int bt_mesh_cfg_hb_pub_get(u16_t net_idx, u16_t addr, struct bt_mesh_cfg_hb_pub *pub, u8_t *status)
{
    if (pub == NULL) {
        return -EINVAL;
    }

    NET_BUF_SIMPLE_DEFINE(msg, 2 + 0 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct hb_pub_param param = {
        .status = status,
        .pub = pub,
    };
    int err;

    err = cli_prepare(&param, OP_HEARTBEAT_PUB_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_HEARTBEAT_PUB_GET);

    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }
    if (!status) {
        cli_reset();
        return 0;
    }
    return cli_wait();
}

/*[Genie begin] add by wenbing.cwb at 2021-01-21*/
#ifdef CONFIG_BT_MESH_CTRL_RELAY
int bt_mesh_cfg_ctrl_relay_get(u16_t net_idx, u16_t addr, struct ctrl_relay_param *cr, u8_t *status)
{
    struct net_buf_simple *msg = NET_BUF_SIMPLE(2 + 0 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct cli_cr_param param = {
        .status = status,
        .cr_p = cr,
    };
    int err;

    err = cli_prepare(&param, OP_CTRL_RELAY_CONF_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(msg, OP_CTRL_RELAY_CONF_GET);

    err = bt_mesh_model_send(cli->model, &ctx, msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }

    if (!status) {
        cli_reset();
        return 0;
    }

    return cli_wait();
}

int bt_mesh_cfg_ctrl_relay_set(u16_t net_idx, u16_t addr, const struct ctrl_relay_param *cr, u8_t *status)
{
    struct net_buf_simple *msg = NET_BUF_SIMPLE(2 + 6 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    struct cli_cr_param param = {
        .status = status,
    };
    int err;

    err = cli_prepare(&param, OP_CTRL_RELAY_CONF_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(msg, OP_CTRL_RELAY_CONF_SET);
    net_buf_simple_add_u8(msg, cr->enable);
    net_buf_simple_add_u8(msg, cr->trd_n);
    net_buf_simple_add_u8(msg, cr->rssi);
    net_buf_simple_add_u8(msg, cr->sta_period);
    net_buf_simple_add_u8(msg, cr->chk_period);
    net_buf_simple_add_u8(msg, cr->req_period);

    err = bt_mesh_model_send(cli->model, &ctx, msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }

    if (!status) {
        cli_reset();
        return 0;
    }

    return cli_wait();
}
#endif
/*[Genie end] add by wenbing.cwb at 2021-01-21*/

int bt_mesh_cfg_node_reset(u16_t net_idx, u16_t addr)
{
    NET_BUF_SIMPLE_DEFINE(msg, 2 + 0 + 4);
    struct bt_mesh_msg_ctx ctx = {
        .net_idx = net_idx,
        .app_idx = BT_MESH_KEY_DEV,
        .addr = addr,
        .send_ttl = BT_MESH_TTL_DEFAULT,
    };
    int err;

    err = cli_prepare(NULL, OP_NODE_RESET_STATUS);
    if (err) {
        return err;
    }

    bt_mesh_model_msg_init(&msg, OP_NODE_RESET);
    err = bt_mesh_model_send(cli->model, &ctx, &msg, NULL, NULL);
    if (err) {
        BT_ERR("model_send() failed (err %d)", err);
        cli_reset();
        return err;
    }

    return cli_wait();
}

bt_s32_t bt_mesh_cfg_cli_timeout_get(void)
{
    return msg_timeout / MSEC_PER_SEC;
}

void bt_mesh_cfg_cli_timeout_set(bt_s32_t timeout)
{
    msg_timeout = K_SECONDS(timeout);
}

int bt_mesh_cfg_cli_init(struct bt_mesh_model *model, bool primary)
{
    BT_DBG("primary %u", primary);

    if (!primary) {
        BT_ERR("Configuration Client only allowed in primary element");
        return -EINVAL;
    }

    if (!model || !model->user_data) {
        BT_ERR("No Configuration Client context provided");
        return -EINVAL;
    }

    cli = model->user_data;
    cli->model = model;

    /* Configuration Model security is device-key based */
    model->keys[0] = BT_MESH_KEY_DEV;
    k_sem_init(&cli->op_sync, 0, 1);

    return 0;
}

#endif
